home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / CodeWarrior Lite / Metrowerks C⁄C++ Lite / Libraries / Runtime / Runtime PPC / Sources / CPlusLibPPC.cp < prev    next >
Encoding:
Text File  |  1995-04-06  |  3.4 KB  |  154 lines  |  [TEXT/MPCC]
  1.  
  2. /*
  3.  *    CPlusLibPPC.cp        -    C++ Runtime Support Routines for Metrowerks C++ (PowerPC)
  4.  *
  5.  *    Copyright © 1993 metrowerks inc. All Rights Reserved.
  6.  *
  7.  */
  8.  
  9. #include <CPlusLib.h>
  10.  
  11.  
  12. /*
  13.  *    __ptmf_cast    -    copy/cast a pointer-to-member-function
  14.  *
  15.  */
  16.  
  17. PTMF *__ptmf_cast(long offset, const PTMF *ptmfrom, PTMF *ptmto)
  18. {
  19.     ptmto->this_delta = ptmfrom->this_delta+offset;
  20.     
  21.     if(ptmfrom->vtbl_offset >= 0L) {        //    virtual function pointer
  22.         ptmto->vtbl_offset = ptmfrom->vtbl_offset + offset;
  23.         ptmto->func_data.ventry_offset = ptmfrom->func_data.ventry_offset;
  24.     }
  25.     else {                                //    nonvirtual function pointer
  26.         ptmto->vtbl_offset = -1L;
  27.         ptmto->func_data.func_addr = ptmfrom->func_data.func_addr;
  28.     }
  29.     
  30.     return(ptmto);
  31. }
  32.  
  33.  
  34. /*
  35.  *    __copy        -    copy 'size' bytes data from 'from' to 'to'
  36.  *
  37.  *    We return the pointer to the destination. If it is 0, no copy is performed.
  38.  *
  39.  */
  40.  
  41. void *__copy(char *to, char *from, size_t size)
  42. {
  43.     char *p;
  44.     
  45.     if (to && size) {
  46.         p = to;
  47.         do {
  48.             *p = *from;
  49.             ++p;
  50.             ++from;
  51.             --size;
  52.         } while (size);
  53.     }
  54.     
  55.     return(to);
  56. }
  57.  
  58.  
  59. /*
  60.  *    __init_arr    -    initialize an array of objects
  61.  *
  62.  *    Given a pointer to space for an array of 'nobjects' elements of size 'objectsize',
  63.  *    and space to store 'nobjects' and 'objectsize' (for later deletion), we call
  64.  *    the given constructor for each object in the array.
  65.  *
  66.  */
  67.  
  68. void *__init_arr(void *memptr, ConstructorDestructor constructor, size_t objectsize, size_t nobjects)
  69. {
  70.     char *p;
  71.     
  72.     if ((p = (char *) memptr) != 0) {
  73.         ((size_t *) p)[0] = objectsize;
  74.         ((size_t *) p)[1] = nobjects;
  75.         p += 2 * sizeof(size_t);
  76.         if (constructor) {
  77.             for (; nobjects--; p += objectsize)
  78.                 (*constructor)(p, 1);
  79.         }
  80.     }
  81.     
  82.     return(memptr);
  83. }
  84.  
  85.  
  86. /*
  87.  *    __new_arr    -    allocate and construct an array of objects
  88.  *
  89.  *    We allocate space for an array of 'nobjects' elements of size 'objectsize', and
  90.  *    space to store 'nobjects' and 'objectsize' (for later deletion). Then we call
  91.  *    the given constructor for each object in the array.
  92.  *
  93.  */
  94.  
  95. void *__new_arr(ConstructorDestructor constructor, size_t objectsize, size_t nobjects)
  96. {
  97.     char *memptr, *p;
  98.     
  99.     if ((memptr = (char *) ::operator new(2*sizeof(size_t) + nobjects*objectsize)) != 0) {
  100.         memptr += 2*sizeof(size_t);
  101.         ((size_t *) memptr)[-2] = objectsize;
  102.         ((size_t *) memptr)[-1] = nobjects;
  103.         if (constructor) {
  104.             for (p = memptr; nobjects--; p += objectsize)
  105.                 (*constructor)(p, 1);
  106.         }
  107.     }
  108.     
  109.     return(memptr);
  110. }
  111.  
  112.  
  113. /*
  114.  *    __del_arr    -    destroy and deallocate an array of objects
  115.  *
  116.  *    We use the previously saved 'nobjects' and 'objectsize' values to call the
  117.  *    destructor for each element of the array. Then we delete the space allocated
  118.  *    to it.
  119.  *
  120.  */
  121.  
  122. void __del_arr(void *memptr, ConstructorDestructor destructor)
  123. {
  124.     size_t nobjects, objectsize;
  125.     char *p;
  126.     
  127.     if (memptr) {
  128.         if (destructor) {
  129.             objectsize = ((size_t *) memptr)[-2];
  130.             nobjects = ((size_t *) memptr)[-1];
  131.             for (p = (char *) memptr+objectsize*nobjects; nobjects--;)
  132.                 (*destructor)(p -= objectsize, -1);
  133.         }
  134.         ::delete (&((size_t *) memptr)[-2]);
  135.     }
  136. }
  137.  
  138.  
  139. /*
  140.  *    __dc_arr    -    construct or destroy a statically allocated array of objects
  141.  *
  142.  *    We call the given constructor or destructor for each of 'nobjects' elements of size
  143.  *    'objectsize' in a statically allocated array.
  144.  *
  145.  */
  146.  
  147. void __dc_arr(void *memptr, ConstructorDestructor constructordestructor, short objectsize, short nobjects)
  148. {
  149.     char *p;
  150.     
  151.     for (p = (char *) memptr; nobjects--; p += objectsize)
  152.         (*constructordestructor)(p, -1);
  153. }
  154.